package com.dxg.msns.user.controller;

import com.dxg.msns.common.pojo.PageResult;
import com.dxg.msns.common.pojo.UserHistory;
import com.dxg.msns.common.pojo.UserHistoryDetailVO;
import com.dxg.msns.common.util.Result;
import com.dxg.msns.user.service.UserHistoryService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 用户播放记录控制器
 */
@RestController
@RequestMapping("/api/user/playRecord")
public class PlayRecordController {

    @Autowired
    private UserHistoryService userHistoryService;

    /**
     * 添加用户播放历史记录
     * 
     * @param userHistory 用户历史记录对象
     * @return 操作结果
     */
    @PostMapping("/add")
    public Result<String> addUserHistory(@RequestBody UserHistory userHistory) {
        try {
            String result = userHistoryService.addOrUpdateUserHistory(userHistory);

            if (result.contains("成功")) {
                return Result.success(result);
            } else {
                return Result.error(result);
            }
        } catch (Exception e) {
            System.err.println("添加用户历史记录异常：" + e.getMessage());
            e.printStackTrace();
            return Result.error("添加历史记录失败：" + e.getMessage());
        }
    }

    /**
     * 分页查询用户历史记录
     * 
     * @param userId 用户ID
     * @param page   页码，默认为1
     * @param rows   每页大小，默认为10
     * @return 分页结果
     */
    @GetMapping("/page")
    public Result<PageResult<UserHistory>> queryUserHistoryByPage(
            @RequestParam("userId") String userId,
            @RequestParam(value = "page", defaultValue = "1") Integer page,
            @RequestParam(value = "rows", defaultValue = "10") Integer rows) {
        try {
            PageResult<UserHistory> result = userHistoryService.queryUserHistoryByPage(userId, page, rows);
            return Result.success("查询成功", result);
        } catch (Exception e) {
            System.err.println("分页查询用户历史记录异常：" + e.getMessage());
            e.printStackTrace();
            return Result.error("查询失败：" + e.getMessage());
        }
    }

    /**
     * 分页查询用户历史记录详情（包含音乐信息和收藏状态）
     * 
     * @param userId 用户ID
     * @param page   页码，默认为1
     * @param rows   每页大小，默认为10
     * @return 分页结果
     */
    @GetMapping("/details/page")
    public Result<PageResult<UserHistoryDetailVO>> queryUserHistoryDetailsWithPage(
            @RequestParam("userId") String userId,
            @RequestParam(value = "page", defaultValue = "1") Integer page,
            @RequestParam(value = "rows", defaultValue = "10") Integer rows) {
        try {
            PageResult<UserHistoryDetailVO> result = userHistoryService.queryUserHistoryDetailsWithPage(userId, page,
                    rows);
            return Result.success("查询成功", result);
        } catch (Exception e) {
            System.err.println("分页查询用户历史记录详情异常：" + e.getMessage());
            e.printStackTrace();
            return Result.error("查询失败：" + e.getMessage());
        }
    }

    /**
     * 查询用户所有历史记录
     * 
     * @param userId 用户ID
     * @return 历史记录列表
     */
    @GetMapping("/all")
    public Result<List<UserHistory>> queryUserHistoryAll(@RequestParam("userId") String userId) {
        try {
            List<UserHistory> result = userHistoryService.queryUserHistoryAll(userId);
            return Result.success("查询成功", result);
        } catch (Exception e) {
            System.err.println("查询用户所有历史记录异常：" + e.getMessage());
            e.printStackTrace();
            return Result.error("查询失败：" + e.getMessage());
        }
    }

    /**
     * 查询用户所有历史记录详情（包含音乐信息和收藏状态）
     * 
     * @param userId 用户ID
     * @return 历史记录详情列表
     */
    @GetMapping("/details/all")
    public Result<List<UserHistoryDetailVO>> queryUserHistoryDetailsAll(@RequestParam("userId") String userId) {
        try {
            List<UserHistoryDetailVO> result = userHistoryService.queryUserHistoryDetailsAll(userId);
            return Result.success("查询成功", result);
        } catch (Exception e) {
            System.err.println("查询用户所有历史记录详情异常：" + e.getMessage());
            e.printStackTrace();
            return Result.error("查询失败：" + e.getMessage());
        }
    }

    /**
     * 根据用户ID和音乐ID查询特定历史记录
     * 
     * @param userId  用户ID
     * @param musicId 音乐ID
     * @return 历史记录
     */
    @GetMapping("/query")
    public Result<UserHistory> queryUserHistoryByUserIdAndMusicId(
            @RequestParam("userId") String userId,
            @RequestParam("musicId") String musicId) {
        try {
            UserHistory result = userHistoryService.queryUserHistoryByUserIdAndMusicId(userId, musicId);
            if (result != null) {
                return Result.success("查询成功", result);
            } else {
                return Result.error("未找到相关历史记录");
            }
        } catch (Exception e) {
            System.err.println("查询特定历史记录异常：" + e.getMessage());
            e.printStackTrace();
            return Result.error("查询失败：" + e.getMessage());
        }
    }

    /**
     * 统计用户历史记录总数
     * 
     * @param userId 用户ID
     * @return 历史记录总数
     */
    @GetMapping("/count")
    public Result<Long> countUserHistory(@RequestParam("userId") String userId) {
        try {
            Long count = userHistoryService.countUserHistory(userId);
            return Result.success("统计成功", count);
        } catch (Exception e) {
            System.err.println("统计用户历史记录异常：" + e.getMessage());
            e.printStackTrace();
            return Result.error("统计失败：" + e.getMessage());
        }
    }

    /**
     * 清空用户所有历史记录
     * 
     * @param userId 用户ID
     * @return 操作结果
     */
    @DeleteMapping("/clear")
    public Result<String> clearUserHistory(@RequestParam("userId") String userId) {
        try {
            String result = userHistoryService.clearUserHistory(userId);

            if (result.contains("成功")) {
                return Result.success(result);
            } else {
                return Result.error(result);
            }
        } catch (Exception e) {
            System.err.println("清空用户历史记录异常：" + e.getMessage());
            e.printStackTrace();
            return Result.error("清空失败：" + e.getMessage());
        }
    }

    /**
     * 删除特定的历史记录
     * 
     * @param userId  用户ID
     * @param musicId 音乐ID
     * @return 操作结果
     */
    @DeleteMapping("/delete")
    public Result<String> deleteUserHistory(
            @RequestParam("userId") String userId,
            @RequestParam("musicId") String musicId) {
        try {
            String result = userHistoryService.deleteUserHistory(userId, musicId);

            if (result.contains("成功")) {
                return Result.success(result);
            } else {
                return Result.error(result);
            }
        } catch (Exception e) {
            System.err.println("删除特定历史记录异常：" + e.getMessage());
            e.printStackTrace();
            return Result.error("删除失败：" + e.getMessage());
        }
    }

    // ===== 以下是供其他微服务Feign调用的简化接口 =====

    /**
     * 简化的添加历史记录接口（供Feign调用）
     * 
     * @param userId  用户ID
     * @param musicId 音乐ID
     * @return 操作结果消息
     */
    @PostMapping("/addHistory")
    public String addUserHistoryForFeign(@RequestParam("userId") String userId,
            @RequestParam("musicId") String musicId) {
        try {
            UserHistory userHistory = new UserHistory(userId, musicId);
            return userHistoryService.addOrUpdateUserHistory(userHistory);
        } catch (Exception e) {
            System.err.println("Feign添加用户历史记录异常：" + e.getMessage());
            e.printStackTrace();
            return "添加历史记录失败：" + e.getMessage();
        }
    }

    /**
     * 简化的统计历史记录接口（供Feign调用）
     * 
     * @param userId 用户ID
     * @return 历史记录总数
     */
    @GetMapping("/countForFeign")
    public Long countUserHistoryForFeign(@RequestParam("userId") String userId) {
        try {
            return userHistoryService.countUserHistory(userId);
        } catch (Exception e) {
            System.err.println("Feign统计用户历史记录异常：" + e.getMessage());
            e.printStackTrace();
            return 0L;
        }
    }

    /**
     * 简化的清空历史记录接口（供Feign调用）
     * 
     * @param userId 用户ID
     * @return 操作结果消息
     */
    @DeleteMapping("/clearForFeign")
    public String clearUserHistoryForFeign(@RequestParam("userId") String userId) {
        try {
            return userHistoryService.clearUserHistory(userId);
        } catch (Exception e) {
            System.err.println("Feign清空用户历史记录异常：" + e.getMessage());
            e.printStackTrace();
            return "清空失败：" + e.getMessage();
        }
    }

    /**
     * 简化的删除特定历史记录接口（供Feign调用）
     * 
     * @param userId  用户ID
     * @param musicId 音乐ID
     * @return 操作结果消息
     */
    @DeleteMapping("/deleteForFeign")
    public String deleteUserHistoryForFeign(@RequestParam("userId") String userId,
            @RequestParam("musicId") String musicId) {
        try {
            return userHistoryService.deleteUserHistory(userId, musicId);
        } catch (Exception e) {
            System.err.println("Feign删除特定历史记录异常：" + e.getMessage());
            e.printStackTrace();
            return "删除失败：" + e.getMessage();
        }
    }
}
